package com.iuie.ns.frame.utils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

/**
 * 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
 * 
 * @author jfeng
 * @version 2014-03-04
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {

	/**
	 * 替换掉HTML标签方法
	 */
	public static String replaceHtml(String html) {
		if (isBlank(html)) {
			return "";
		}
		String regEx = "<.+?>";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(html);
		String s = m.replaceAll("");
		return s;
	}

	/**
	 * 缩略字符串（不区分中英文字符）
	 * 
	 * @param str
	 *            目标字符串
	 * @param length
	 *            截取长度
	 * @return
	 */
	public static String abbr(String str, int length) {
		if (str == null) {
			return "";
		}
		try {
			StringBuilder sb = new StringBuilder();
			int currentLength = 0;
			for (char c : str.toCharArray()) {
				currentLength += String.valueOf(c).getBytes("GBK").length;
				if (currentLength <= length - 3) {
					sb.append(c);
				} else {
					sb.append("...");
					break;
				}
			}
			return sb.toString();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return "";
	}

	/**
	 * 转换为BigDecimal类型
	 */
	public static BigDecimal toBigDecimal(Object val) {
		return BigDecimal.valueOf(toDouble(val));
	}

	/**
	 * 转换为Double类型
	 */
	public static Double toDouble(Object val) {
		if (val == null) {
			return 0D;
		}
		try {
			return Double.valueOf(trim(val.toString()));
		} catch (Exception e) {
			return 0D;
		}
	}

	/**
	 * 转换为Float类型
	 */
	public static Float toFloat(Object val) {
		return toDouble(val).floatValue();
	}

	/**
	 * 转换为Long类型
	 */
	public static Long toLong(Object val) {
		return toDouble(val).longValue();
	}

	/**
	 * 转换为Integer类型
	 */
	public static Integer toInteger(Object val) {
		return toLong(val).intValue();
	}

	/**
	 * 获得用户远程地址
	 */
	public static String getRemoteAddr(HttpServletRequest request) {
		String remoteAddr = request.getHeader("X-Real-IP");
		if (isNotBlank(remoteAddr)) {
			remoteAddr = request.getHeader("X-Forwarded-For");
		} else if (isNotBlank(remoteAddr)) {
			remoteAddr = request.getHeader("Proxy-Client-IP");
		} else if (isNotBlank(remoteAddr)) {
			remoteAddr = request.getHeader("WL-Proxy-Client-IP");
		}
		return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
	}

	/**
	 * 判断字条串是否为空
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isEmpty(String str) {
		if (str == null || "".equals(str)) {
			return true;
		}
		return false;
	}
	
	/**
	 * 判断字符串是否为空或空串；其中空串是指经过trim后字符串长度为0。 为空或空串返回true，否则返回false。
	 * @param str
	 * @return
	 */
	public static boolean isBlank(String str) {
		if (str == null || (str.trim()).equals(""))
			return true;
		return false;
	}
	
	/**
	 * 判断字符串不是空或空串；其中空串是指经过trim后字符串长度为0。 为空或空串返回false，否则返回true。
	 * 
	 * @param str
	 * @return
	 */
	public static boolean notBlank(String str) {
		return !isBlank(str);
	}
	
	/**
	 * 判断字符串是否相等
	 * @param param0
	 * @param param1
	 * @return
	 */
	public static boolean isEquals(String param0,String param1){
		if (param0 == null && param1 == null) {
			return true;
		}
		if ((param0 == null && param1 == "")|| ((param1 == null && param0 == ""))) {
			return true;
		}
		String target = param0==null?param0:param1;
		if (target == null) {
			return false;
		}
		if (param0 == param1 || param0.equals(param1)) {
			return true;
		}else {
			return false;
		}
	}
	
	/**
	 * 判断字符串数组中包含某个字符串。 包含返回true，否则返回false。 例： String[] s = {"a", "b"};
	 * contains(s, "a"); // 返回true
	 * @param array
	 * @param str
	 * @return
	 */
	public static boolean contains(String[] array, String str) {
		if (isBlank(str) || array == null)
			return false;
		for (int i = 0; i < array.length; i++) {
			if (str.equals(array[i]))
				return true;
		}
		return false;
	}
	
	/**
	 * 判断字符串数组中包含某个字符串。不区分大小写。 包含返回true，否则返回false。 例： String[] s = {"a", "b"};
	 * contains(s, "a"); // 返回true
	 * 
	 * @param array
	 * @param str
	 * @return
	 */
	public static boolean containsIgnoreCase(String[] array, String str) {
		if (isBlank(str) || array == null)
			return false;
		for (int i = 0; i < array.length; i++) {
			if (str.equalsIgnoreCase(array[i]))
				return true;
		}
		return false;
	}
	
	/**
	 * 判断某个字符串在字符串数组中的位置。 返回-1表示数组不存在该字符串。 例： String[] s = {"a", "b"};
	 * position(s, "a"); // 返回0
	 * 
	 * @param array
	 * @param str
	 * @return
	 */
	public static int position(String[] array, String str) {
		if (isBlank(str) || array == null)
			return -1;
		for (int i = 0; i < array.length; i++) {
			if (str.equals(array[i]))
				return i;
		}
		return -1;
	}
	/**
	 * 判断某个字符串在字符串数组中的位置，允许跳过部分字符串。 如果设置method，表示str以array中某个串开始或结束
	 * <p>String[] array={"abc","acb","bac","bca","cba","cab"};<br/>
	 * String str="bacabc";<br/>
	 * int step=2;<br/>
	 * posStep(array,str,step,"s"); // 返回2，array[2]="bac",str start with "bac"<br/>
	 * posStep(array,str,step,"e"); // 返回0，array[0]="abc",str end with "abc"</p>
	 * @param array
	 * @param str
	 * @param step 步长
	 * @param method
	 *            "s"开始 "e"结束 其他表示相同
	 * @return
	 */
	public static int posStep(String[] array, String str, int step,
			String method) {
		if (isBlank(str) || array == null)
			return -1;
		for (int i = 0; i < array.length; i++) {
			if (step > 0 && i % step != 0) {
				continue;
			}
			if ("s".equalsIgnoreCase(method)) {
				if (str.startsWith(array[i])) {
					return i;
				}
			} else if ("e".equalsIgnoreCase(method)) {
				if (str.endsWith(array[i])) {
					return i;
				}
			} else {
				if (str.equals(array[i])) {
					return i;
				}
			}
		}
		return -1;
	}
	/**
	 * 获取字符串在一个字符串数组中的位置，忽略这个字符串str的大小写
	 * @param array
	 * @param str
	 * @return
	 * @author lj
	 * @date 2017年5月23日 下午11:01:08
	 */
	public static int posIgnoreCase(String[] array, String str) {
		if (isBlank(str) || array == null)
			return -1;
		for (int i = 0; i < array.length; i++) {
			if (str.equalsIgnoreCase(array[i]))
				return i;
		}
		return -1;
	}

	/**
	 * 字符串过长处理，超出len长度，打省略号并返回
	 * @param s
	 * @param len
	 * @return
	 */
	public static String strTooLong(String s, int len) {
		if (isBlank(s) || len < 1 || s.length() <= len)
			return s;
		String ret = s.substring(0, len) + "...";
		return ret;
	}
	
	/**
	 * 根据指定分隔拆分字符串，返回字符串数组。 例： String[] s = strBreak("a.b.c.d.e","."); //
	 * s为{"a","b","c","d","e"}
	 * 
	 * @param array
	 * @param str
	 * @return
	 */
	public static String[] strBreak(String str, String delim) {
		if (isBlank(str) || isBlank(delim))
			return null;
		StringTokenizer st = new StringTokenizer(str, delim);
		int length = st.countTokens();
		if (length < 1)
			return null;
		String[] strArray = new String[length];
		String s = null;
		int i = 0;
		while (st.hasMoreTokens()) {
			s = st.nextToken();
			strArray[i++] = s;
		}
		return strArray;
	}

	/**
	 * 根据指定分隔拆分字符串，返回字符串数组。 不剔出空字符串 例： String[] s = strBreak("a.b.c..d","."); //
	 * s为{"a","b","c","","e"}
	 * 
	 * @param array
	 * @param str
	 * @return
	 */
	public static String[] strBreakWithBlank(String str, String delim) {
		if (isBlank(str) || isBlank(delim))
			return null;
		String[] strArray = str.split("\\" + delim);
		return strArray;
	}

	/**
	 * 根据指定分隔组合字符串数组，返回字符串。 例： String[] s = {"a","b","c","d","e"}; String t =
	 * strJoin(s, "."); // t为"a.b.c.d.e"
	 * 
	 * @param strArray
	 * @param str
	 * @return
	 */
	public static String strJoin(String[] strArray, String delim) {
		if (strArray == null || isBlank(delim))
			return null;
		String str = "";
		String td = "";
		int length = strArray.length;
		for (int i = 0; i < length; i++) {
			if (notBlank(strArray[i])) {
				str += td + strArray[i];
				td = delim;
			}
		}
		return str;
	}

	/**
	 * 组合字符串数组用于sql的in条件字符串。 例： String[] s = {"a","b","c","d","e"}; String t =
	 * strJoin(s); // t为'a','b','c','d','e'
	 * 
	 * @param strArray
	 * @return
	 */
	public static String strJoinAsIn(String[] strArray) {
		if (strArray == null)
			return null;
		String str = "";
		String td = "";
		int length = strArray.length;
		for (int i = 0; i < length; i++) {
			if (notBlank(strArray[i])) {
				str += td + "'" + strArray[i] + "'";
				td = ",";
			}
		}
		return str;
	}

	/**
	 * 首字母大写。 例： String s = initialUpperCase("word"); // 返回值为"Word"
	 * 
	 * @param str
	 * @return
	 */
	public static String initialUpperCase(String str) {
		if (isBlank(str))
			return str;
		String ret = str.substring(0, 1);
		ret = ret.toUpperCase() + str.substring(1);
		return ret;
	}
	
	/**
	 * 将GB2312字符串转成ISO8859-1字符串
	 * 
	 * @param String
	 *            GB2312字符串
	 * @return String ISO8859-1字符串
	 */
	public static String getUTF4GB(String str) {
		if (str == null)
			return null;
		try {
			return new String(str.getBytes("GB2312"), "ISO8859_1");
		} catch (Exception e) {
			return str;
		}
	}
	
	/**
	 * 将ISO8859-1字符串转成GBK字符串
	 * 
	 * @param String
	 *            ISO8859-1字符串
	 * @return String GBK字符串
	 */
	public static String getGBStr(String str) {
		if (str == null)
			return null;
		try {
			return new String(str.getBytes("ISO8859_1"), "GBK");
		} catch (Exception e) {
			return str;
		}
	}
	
	/**
	 * 控制得到的字符串不为空
	 * 
	 * @param s
	 * @return
	 */
	public static String getNotNull(String s) {
		if (s == null || s.trim().equals(""))
			return "";
		return s;
	}

	/**
	 * 控制得到的字符串的显示
	 * 
	 * @param s
	 * @return
	 */
	public static String formatNull(String s) {
		if (s == null || s.trim().equals(""))
			return "/";
		return s;
	}
	
	/**
	 * 处理页面的显示,将\n,转为<br>
	 * ,如果长度超过50个字符,添加一个<br>
	 * 
	 * @param str
	 * @return
	 */
	public static String getHtmlStr(String str) {
		// 去除字符串中的html标签
		if (isBlank(str))
			return str;
		str = str.replaceAll("<", "&lt;");
		str = str.replaceAll(">", "&gt;");
		str = str.replaceAll("\n", "<br>");
		str = str.replaceAll("\"", "&quot;");
		str = str.replaceAll(" ", "&nbsp;");
		return str;
	}

	/**
	 * 得到utf格式的字符串,可应用于下载文件时,对文件名的处理
	 */
	public static String toUtf8String(String s) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (c >= 0 && c <= 255) {
				sb.append(c);
			} else {
				byte[] b;
				try {
					b = Character.toString(c).getBytes("utf-8");
				} catch (Exception ex) {
					System.out.println(ex);
					b = new byte[0];
				}
				for (int j = 0; j < b.length; j++) {
					int k = b[j];
					if (k < 0)
						k += 256;
					sb.append("%" + Integer.toHexString(k).toUpperCase());
				}
			}
		}
		return sb.toString();
	}
	
	/**
	 * 
	 * @param d
	 * @return
	 */
	public static double getAmtPart(double d, double part, int k) {
		double a = d * part / k;
		Double c = new Double(a);
		int b = c.intValue();
		a = 1.00 * b * k;
		return a;
	}

	/**
	 * 格式化字段
	 * 
	 * @param validPat
	 * @param value
	 * @return 是否被格式化.
	 */
	public static String formatValue(String validPat, String value) {
		if (validPat.equals("currencyPat")) { // 金额
			value = NumberUtils.formatNumber((String) value, 2);
		} else if (validPat.equals("shortStrPat")) { // 短字符串
			if (value.length() > 10) {
				value = value.substring(0, 10);
				value = value + "...";
			}
		} else if (validPat.equals("exRatePat")) { // 外汇牌价
			value = NumberUtils.formatNumber((String) value, 4);
		} else if (validPat.equals("10kPat")) { // 万元
			value = NumberUtils.formatNumber((String) value, 2, 2) + "万";
		} else if (validPat.equals("numberPat")) { // 整数
			value = NumberUtils.formatNumber((String) value, 0, 0);
		} else if (validPat.equals("currIntPat")) { // 无小数金额
			value = NumberUtils.formatNumber((String) value, 0);
		} else if (validPat.equals("ratePat")) { // %
			value = NumberUtils.formatNumber((String) value, 4, 1) + "%";
		} else if (validPat.equals("ratePat1")) { // %
			value = NumberUtils.formatNumber((String) value, 4, 1) + "";
		} else if (validPat.equals("rate0Pat")) { // %
			value = NumberUtils.formatNumber((String) value, 0, 1) + "%";
		} else if (validPat.equals("rate2Pat")) { // %
			value = NumberUtils.formatNumber((String) value, 2, 1) + "%";
		} else if (validPat.equals("ratefPat")) { // %
			value = NumberUtils.formatNumber((String) value, 4, 1) + "%";
		} else if (validPat.equals("rate2fPat")) { // %
			value = NumberUtils.formatNumber((String) value, 2, 1) + "%";
		} else if (validPat.equals("monthPat")) { // 月
			int t = NumberUtils.parseInt((String) value);
			int y = t / 12;
			int m = t % 12;
			if (m <= 0) {
				value = y + "年";
			} else if (y <= 0) {
				if (m == 6)
					value = "半年";
				else
					value = m + "个月";
			} else {
				if (m == 6)
					value = y + "年半";
				else
					value = y + "年零" + m + "个月";
			}
		} else if (validPat.equals("datePat")) { // 日期
			value = DateUtils.formatDate((String) value, "yyyy-MM-dd",
					"yyyy年M月d日");
		} else if (validPat.equals("dateInputPat")) { // 日期
			value = DateUtils.formatDate((String) value, "yyyy-MM-dd");
		} else if (validPat.equals("datetimePat")) { // 日期时间
			String date = DateUtils.getDateOfDT(value);
			String time = DateUtils.getTimeOfDT(value);
			if (notBlank(date)) {
				date = DateUtils.formatDate((String) date, "yyyy-MM-dd", "yyyy年M月d日");
				if (notBlank(time)) {
					value = date + " " + time;
				} else {
					value = date;
				}
			}
		} else if (validPat.equals("shortDatePat")) {
			String date = DateUtils.getDateOfDT(value);
			if (notBlank(date)) {
				date = DateUtils.formatDate((String) date, "yyyy-MM-dd", "MM-dd");
				value = date;
			}
		} else if (validPat.equals("shortDateTimePat")) {
			String date = DateUtils.getDateOfDT(value);
			String time = DateUtils.getTimeOfDT(value);
			if (time.length() == 8) {
				time = time.substring(0, 5);
			}
			if (notBlank(date)) {
				date = DateUtils.formatDate((String) date, "yyyy-MM-dd", "MM-dd");
				if (notBlank(time)) {
					value = date + " " + time;
				} else {
					value = date;
				}
			}
		} else if (validPat.equals("yearMonthPat")) {
			value = DateUtils.formatDate((String) value, "yyyyMM", "yyyy年M月");
		} else if (validPat.equals("jdPat")) {
			String year = (String) value.substring(0, 4);
			int month = NumberUtils.parseInt((String) value.substring(4));
			if (month <= 3)
				value = year + "年一季度";
			else if (month > 3 && month <= 6)
				value = year + "年二季度";
			else if (month > 6 && month <= 9)
				value = year + "年三季度";
			else if (month > 9)
				value = year + "年四季度";
		}
		// System.out.println("validPat="+validPat+"value="+value);
		return value;
	}

	/**
	 * 字符串替换
	 * 
	 * @param oldStr
	 *            原有的字符串
	 * @param subStr
	 *            被替换的字符串
	 * @param rStr
	 *            替换的字符串
	 * @return 返回替换后的字符串
	 */
	public static String replaceAll(String oldStr, String subStr, String rStr) {
		int i = oldStr.indexOf(subStr);
		int sl = subStr.length();
		String rsltStr = oldStr;
		while (i != -1) {
			String fStr = rsltStr.substring(0, i);
			String eStr = rsltStr.substring(i + sl, rsltStr.length());
			rsltStr = fStr + rStr + eStr;
			i = rsltStr.indexOf(subStr);
		}
		return rsltStr;
	}

	/**
	 * 获得定长的字符串
	 * 
	 * @param strInput
	 *            输入字符串
	 * @param strAddChar
	 *            前补的字符
	 * @param intSize
	 *            字符的长度
	 * @return
	 * @author 曹利娟
	 */
	public static String getFixString(String strInput, String strAddChar,
			int intSize) {
		if (strInput.length() > intSize)
			strInput = strInput.substring(0, intSize);
		while (strInput.length() < intSize) {
			strInput = strAddChar + strInput;
		}
		return strInput;
	}

	/**
	 * 将18位身份证转为15位
	 * 
	 * @param oldStr
	 * @return
	 */
	public static String get15IDCard(String oldStr) {
		if (oldStr == null || oldStr.length() != 18) {
			return null;
		}
		String pre6 = oldStr.substring(0, 6);
		String ends = oldStr.substring(8, 17);
		return pre6 + ends;
	}

	/**
	 * 将15位身份证号转换为18位身份证号
	 * 
	 * @param 15位身份证号
	 * @param 世纪
	 * @return 返回替换后的字符串
	 */
	public static String get18IDCard(String oldStr, String cenStr) {
		if (oldStr == null || oldStr.length() != 15) {
			return null;
		}
		/*
		 * 1、号码的结构 公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。
		 * 排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。 2、地址码
		 * 表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。 3、出生日期码
		 * 表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。 4、顺序码
		 * 表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号， 顺序码的奇数分配给男性，偶数分配给女性。 5、校验码
		 * （1）十七位数字本体码加权求和公式 S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和
		 * Ai:表示第i位置上的身份证号码数字值 Wi:表示第i位置上的加权因子 Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5
		 * 8 4 2 （2）计算模 Y = mod(S, 11) （3）通过模得到对应的校验码 Y: 0 1 2 3 4 5 6 7 8 9 10
		 * 校验码: 1 0 X 9 8 7 6 5 4 3 2
		 */
		if (StringUtils.isBlank(cenStr)) {
			cenStr = "19";
		}
		String newStr = oldStr.substring(0, 6) + cenStr + oldStr.substring(6);
		int w[] = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
		int s = 0;
		for (int i = 0; i < 17; i++) {
			String a = newStr.substring(i, i + 1);
			s = s + w[i] * NumberUtils.parseInt(a);
		}
		int y = s % 11;
		String m[] = { "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2" };
		newStr = newStr + m[y];
		return newStr;
	}

	/**
	 * 产生符合正态分布（高斯分布）的随机数
	 * 
	 * @param 均值
	 * @param 标准差
	 * @return 返回随机数
	 */
	public static double gaussianRNG(double mu, double sigma) {
		if (sigma <= 0.0) {
			return mu;
		}
		/*
		 * 理论证明12个[0,1]间的均匀分布之和标准化后能很好的近似一个标准正态随机变量.
		 */
		/*
		 * double r,sum=0.0;
		 * 
		 * for ( int i=1; i<=12; i++ ) { sum = sum + Math.random(); } r =
		 * (sum-6.00) * sigma + mu;
		 * 
		 * return r;
		 */
		/*
		 * Box 和 Muller 在 1958 年给出了由均匀分布的随机变量生成正态分布的随机变量的算法。 设 U1, U2 是区间 (0, 1)
		 * 上均匀分布的随机变量，且相互独立。 X1 = sqrt(-2*log(U1)) * cos(2*PI*U2); X2 =
		 * sqrt(-2*log(U1)) * sin(2*PI*U2);
		 */
		double r1 = Math.random();
		double r2 = Math.random();
		return Math.sqrt(-2 * Math.log(r1)) * Math.cos(2 * Math.PI * r2)
				* sigma + mu;
	}

	public static String byte2hex(byte[] b) {
		String hs = "";
		String stmp = "";
		for (int n = 0; b != null && n < b.length; n++) {
			stmp = (Integer.toHexString(b[n] & 0XFF));
			if (stmp.length() == 1) {
				hs = hs + "0" + stmp;
			} else {
				hs = hs + stmp;
			}
			// if (n<b.length-1) hs=hs+":";
		}
		return hs.toUpperCase();
	}

	/**
	 * 把InputStream 转成String
	 * @param input
	 * @return
	 * @throws IOException
	 */
	public static String convertInputStreamToString(InputStream input)throws IOException{
		
		if(input!=null){
			StringBuilder sb = new StringBuilder();
			String line;
		 try{
			BufferedReader reader = new BufferedReader(new InputStreamReader(input,"utf-8"));
			while((line = reader.readLine())!=null){
				sb.append(line).append("\n");
			}
		   }finally{
			   input.close();
		   }
		   return sb.toString();
		}else{
			return "";
		}

	}
	
	/**
	 * 获取UUID
	 * @return
	 * @author lj
	 * @date 2017年5月26日 上午10:43:03
	 */
	public static String uuid() {
		String uuid = UUID.randomUUID().toString();
		uuid = StringUtils.upperCase(uuid);
		return uuid.replace("-", "");
	}
	
	public static Long timestampId() {
		String millis = String.valueOf(System.currentTimeMillis());
		double x = Math.random()*1000;
		int random = (int) x;
		return Long.valueOf(millis + random);
	}
	
	
	public static String str;
	public static final String EMPTY_STRING = "";

	private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",
			"6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };

	private static String byteToHexString(byte b) {
		int n = b;
		if (n < 0)
			n = 256 + n;
		int d1 = n / 16;
		int d2 = n % 16;
		return hexDigits[d1] + hexDigits[d2];
	}

	/**
	 * 转换字节数组为16进制字串
	 * @param b 字节数组
	 * @return 16进制字串
	 */
	public static String byteArrayToHexString(byte[] b) {
		StringBuffer resultSb = new StringBuffer();
		for (int i = 0; i < b.length; i++) {
			resultSb.append(byteToHexString(b[i]));
		}
		return resultSb.toString();
	}

	/**
	 * MD5加密方法
	 * @param origin
	 * @return
	 */
	public static String MD5Encode(String origin) {
		String resultString = null;
		try {
			resultString = new String(origin);
			MessageDigest md = MessageDigest.getInstance("MD5");
			resultString = byteArrayToHexString(md.digest(resultString
					.getBytes()));
		} catch (Exception ex) {
		}
		return resultString;
	}

	/**
	 * 将数组转化成字符串，split为分隔符，如果split为null，那么split=","
	 * @param arr
	 * @param split
	 * @return
	 * @date 2018-01-02 14:52:06
	 * @author iuie
	 */
	public static final String arrayToString(String[] arr, String split) {
		if (arr == null || arr.length == 0) {
			return "";
		}
		if (split == null) {
			split = ",";
		}
		StringBuilder sb = new StringBuilder(12);
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == null || arr[i].length() == 0) {
				continue ;
			}
			sb.append(arr[i]);
			if (i != (arr.length - 1)) {
				sb.append(split);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 将List&lt;String&gt;转化成字符串，split为分隔符，如果split为null，那么split=","
	 * @param list
	 * @param split
	 * @return
	 * @date 2018-01-08 14:43:25
	 * @author iuie
	 */
	public static final String listToString(List<String> list, String split) {
		if (list == null || list.size() == 0) {
			return "";
		}
		if (split == null) {
			split = ",";
		}
		StringBuilder sb = new StringBuilder(12);
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			String s = it.next();
			if (s == null || s.length() == 0) {
				continue ;
			}
			sb.append(s);
			if (it.hasNext()) {
				sb.append(split);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 随机生成长整型数值，其值在min到max之间
	 * @param min
	 * @param max
	 * @return
	 */
	public static final Long randonLong(int min, int max) {
		return Math.round(Math.random()*(max - min) + min);
	}
	
	/**
	 * 产生随机手机号
	 * @return
	 */
	public static final String randonTelNo() {
        StringBuilder sb = new StringBuilder(11);
        sb.append("1");
        for (int i = 0; i < 10; i++ ) {
        	if (i == 0) {
        		sb.append(String.valueOf(StringUtils.randonLong(3, 9)));
        	} else {
        		sb.append(String.valueOf(StringUtils.randonLong(1, 9)));
        	}
        }
		return sb.toString();
	}
	
	/**
	 * 将数据库字段名转为java属性名
	 * @param fieldName
	 * @return
	 */
	public static final String fieldNameToAttributeName(String fieldName) {
		if (StringUtils.isBlank(fieldName)) {
			return null;
		}
		fieldName = StringUtils.lowerCase(fieldName);
		String[] fields = fieldName.split("_");
		StringBuilder sbuilder = new StringBuilder(fields[0]);
		for (int i = 1; i < fields.length; i++) {
            char[] cs=fields[i].toCharArray();
            cs[0]-=32;
            sbuilder.append(String.valueOf(cs));
        }
        return sbuilder.toString();
	}
	
	/**
	 * 格式化json
	 * @param text
	 * @return
	 */
	public static final String formatJson(String text) {

		StringBuilder jsonForMatStr = new StringBuilder();
		String texttrim = text.replaceAll("\\s*", "");
		int length = texttrim.length();
		int level = 0;

		for (int i = 0; i < length; i++) {
			char c = texttrim.charAt(i);

			if (level > 0
					&& '\n' == jsonForMatStr.charAt(jsonForMatStr.length() - 1)) {
				jsonForMatStr.append(getLevelStr(level));
			}

			// 遇到{和[要增加空格和换行
			switch (c) {
			case '{':
			case '[':
				jsonForMatStr.append(c).append("\n");
				level++;
				break;
			case ',':
				jsonForMatStr.append(c).append("\n");
				break;
			case '}':
			case ']':
				jsonForMatStr.append("\n");
				level--;
				jsonForMatStr.append(getLevelStr(level));
				jsonForMatStr.append(c);
				break;
			case ' ':
				break;
			default:
				jsonForMatStr.append(c);
			}
		}
		return jsonForMatStr.toString();

	}

	private static Object getLevelStr(int level) {
		StringBuffer levelStr = new StringBuffer();
		for (int levelI = 0; levelI < level; levelI++) {
			levelStr.append("  ");
		}
		return levelStr.toString();
	}
	
	/**
	 * 判断字符串是否匹配某个正则表达式
	 * @param txt
	 * @param regexp
	 * @return
	 * @date 2018年5月21日上午10:02:58
	 */
	public static boolean match(String txt, String regex) {
		if (txt == null || regex == null) {
			return false;
		}
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(txt);
		return matcher.matches();
	}
	
	/**
	 * 正则表达式匹配文本内容
	 * @param text
	 * @param reg
	 * @return
	 * @date 2018年5月27日下午1:40:11
	 */
	public static String regMatch(String text, String reg) {
		Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(text);
        String result = null;
        while (matcher.find()) {
        	result = matcher.group(1);
        	break;
        }
        return result;
	}

}
